The Corona of the Sun is perhaps the most beautiful thing a human can see with their eyes, or for that matter photograph with a camera. It is the superheated outermost layer of the Sun's atmosphere, composed of tenuous filaments of plasma at temperatures of 1,000,000 degrees Celsius. The Corona is bent and molded by the magnetic and radiative forces of the Sun, forming intricate streamers, loops, and other interesting formations. 

The Location

The Corona can only be observed in the narrow path of totality, the stretch of land that falls under the shadow of the Moon. I found myself in Western Ohio for this eclipse, as I was unable to make it to better weather in Maine after I had to completely change my plans away from Texas! The location had some high clouds, but luckily the data I collected was workable. Here's me setting up in a cornfield with the Askar 103, Redcat 61, and a sigma 135mm (not pictured). 



The Capture

The photographic dynamic range of the Corona is somewhere on the order of 14 stops of dynamic range. This is impossible to photograph with a single exposure. This is THE hardest dynamic range problem in astrophotography. For this reason, we need to capture many bracketed exposures. This image comprises thirteen different exposure times from 1/1000s all the way to 4s long. Using SetNC, I was able to capture 15 of these brackets to make 15 HDR subframes to stack.

You heard me right! Due to the structure of my workflow, each bracket is composed as an HDR subframe to be stacked in the deep sky method, which I will detail later. The other critical thing of note here for the capture is ~calibration~. Calibration of TSE images must be perfect, just as in a deep sky image. For this image I shot around 200 flat frames, 300 bias frames, and 300 dark frames. The dark frames are matched to each of the 13 differing exposure times. I messed up a little bit, because I did not turn off sensor cleaning on my camera, and so two dust bunnies moved inside my frame as I booted my camera after totality and before flats. Note to self and everyone, turn OFF sensor cleaning, and take your flats immediately after totality. It is critical!! The darks and bias were pretty simple to do, I just ran SetNC several times with a lens cap on for the darks, and then simply spray shots for the bias. 



The Processing

Here is where things get a little unhinged. The processing of TSE images is bar-none the single most difficult task in all of astrophotography. There are many different tools you may attempt to throw at the image processing challenges of the TSE, but just as in many things in life, sometimes you have to do it yourself. Inspired by the amazing images of Miloslav Druckmuller, and Nicolas Lefaudeuax, I set out in the year 2018 to develop my own custom software to tackle the challenges of the TSE. 

Little did I know as a naive 18-year-old college student, this undertaking would be extremely difficult, and I wouldn't be able to fully realize the success until a couple days ago! Part of the problem is that this process is reliant on properly calibrated images, which only a handful of people shoot at each eclipse. Regardless, I created a library of some 67 different MATLAB scripts to do many unique tasks for TSE image processing, here are some of those tasks!

Step 1 - Image Registration:

Commonly on YouTube eclipse tutorials, you will see photographers suggest that you align your images by the Moon before doing your HDR blend. This is a forgivable error for the general photographer, but for us deep sky people it just won't do. We know that the Moon shows a very rapid motion across the disc of the Sun, and relative to the Corona. The Moon as our reference will blur the details of the Corona when we stack.

The next best bet is to align by the stars, but due to the dynamic range limit, only the last 2-3 exposures in any bracket will show stars bright enough to align upon. Not to mention, the Sun also moves relative to the stars, meaning the Corona will still be blurred (albeit much less than using the moon). In fact for a wide angle shot, the stars are probably more than good enough to use as a reference. 

But in a perfect world... we would chose to align our images in reference to the Corona in order to preserve its fine details. This is indeed possible but it requires a bit of trickery to get working. Due to the high levels of noise, and incredibly weak structures that we want to target, the only feasible algorithm for us to choose is Phase Correlation. Phase correlation is a highly sensitive frequency domain method for estimating the registration of two images. Not to mention, by using the geometric moment of the phase correlation peak, we can realize the possibility of estimating a subpixel image registration! 

Seems simple enough, but if you go try and dump two raw images into the phase correlation algorithm it will not work. Much preprocessing needs to be done for this to work. Each subframe is made to look like this prior to feeding into the algorithm: 

I will not bore you with too many more details, but this should illustrate the solution. By hiding the Moon's edge, the image edge, and bright stars (yes I know they show in this sub), we can isolate the structure of interest. By isolating the high spatial frequencies, we can eliminate the dynamic range issue, and even register images of many different exposure times with large overexposed regions!

Step 2 - Linear HDR Image Composition

This is by FAR the hardest part of the process. The goal is a perfect blend of exposures free of any HDR artifact, with the Moon's edge sharply composed. If we want to do this perfectly, using all our calibration frames, we HAVE to do it linearly. There is no stretching of each image and blending them in Photoshop. The frame matching and blending are done entirely using algorithms. The principle of the method is simple enough on paper, but very difficult to script.

The method used is a weighted linear HDR function. You may think of every exposure time as containing some brightness values which are underexposed (i.e noisey), properly exposed in the midranges, and overexposed/nonlinear in the highlights. The goal is to reject all the improperly exposed regions of each subframe, and add together all the good stuff into one summed image. The problem is that the structures in each exposure time have different brightness values, and so they all must be matched so that every part of the image from each exposure time has the same brightness. Even the longest blown-out exposures, to the inner corona exposures must be matched for this to work. Once they are matched, we apply our weight function to each sub, add them together, and then divide the result by the sum of all of our weight functions. 

Here is an example of my weight function. w=0 in the bad regions, with a slow ramp up to w=1 for the properly exposed region, (the images are linear so I have to push very close to zero to maintain signal):


The end result (after dealing with the lunar movement) is a dark, linear, HDR image. This can now be treated just like a linear DSO image with your stretching function of choice! The issue I had was that the image could not be handled in FITS format since the dynamic range was so high, resulting in artifacts when stretched. So I had to write my own copy of the STF function so that I could stretch the image in double format in MATLAB.  Additionally, the matching of the frames is very very finicky. In order to accomplish this I had to write my own versions of the 'linear fit' module in Pixinsight which were more adaptable to my needs.

Step 3 - Adaptive Kernel Convolution

When working with the Corona, you must think in terms of the circle. The big problem is how to visualize the fine details in the face of the powerful radial gradient of the Corona. The radial brightness gradient has a comparatively large structure size to the fine streamers, and so we can utilize a high pass filter to weaken the gradient. There are several ways to compute the high pass filter.

One could apply a traditional HPF computed with a Gaussian blur:

Filtered image = Image - Gaussian(Image, radius)

This is fine when the signal is good, but it won't work well here. The inner corona will suffer from ringing of the Moon's edge, and the outer region will be noisy. 

Better yet we could change our blur geometry to work with the circle, this can be done with an Espenak Filter, or simply: 

Filtered image = Image - Tangent_blur(Image, radius)

This is where the image is spin blurred by some amount to isolate tangential details and remove the gradient. It works great, and there is no Moon edge artifact to manage since you don't blur into it radially. But you will neglect to visualize the radial details.



So now we see the need for an adaptive way to blur the image so that we can have our cake and eat it too. This is the function of the ACHF developed by Miloslav Druckmuller, and here I implement my own version. The filter computes the proper blur for each pixel in the image based on its location relative to the limb of the Moon. Where the gradient magnitude of the image crosses a threshold, the filter returns a zero! The actual kernel is a standard gaussian near to the lunar limb to capture details in all directions, but for further radii the kernel transforms into a pure tangent blur like the Espenak Filter for better noise performance. 

The final image is then computed as some weighted sum of our filter, and the original photo. We do need to run this filter for multiple image scales to properly enhance the image, for this image I have composed high pass filters at 0.5px, 1px, 3px, and 10px. 



That is the most interesting novel part of the processing. The rest is painstaking composition of the highpass filters, moon, prominences, stars, etc. All of the data that comprises this image originates from totality. There is no fake moon, no fake stars, all of it was in the data. (Don't ask me how I got rid of the brightness gradient on the Moon). I should also note that in this process, there was no use of AI noise reduction or sharpening programs, but this was not for a lack of trying! I attempted to improve this image from any angle I could, but no AI program knew what to do with the image structure. Interestingly enough, the traditional deconvolution module in PI had a very positive effect for this image on small filaments.

The Result: 



The end result is a sharp and artifact-free visualization of the Corona! Beyond the Corona, we can even clearly visualize the Earthshine of the Moon in our image. The Moon itself comes from raw data captured from totality, there is no composite of a separate Moon captured earlier in the month. Here is the raw Earthshine before and after developing a separate process to remove the edge glow gradient, and correcting for color effects and flares. 



IMO this is a mission success for my 6 year-long coding project. What I've learned in this time has taught me a lot about image processing in general, and has had a positive impact on my astrophotography. It is the prime example of how you can exploit the geometry of a scene for image enhancements.

I hope you all enjoy the image!